#[cfg(test)]
mod tests {
    use crate::{
        aria::{AriaAttributeType, AriaManager},
        DomNode, HtmlParser, ParserConfig,
    };

    #[test]
    fn test_aria_attribute_validation() {
        let aria_manager = AriaManager::new();

        // 测试布尔ARIA属性
        // 只测试实际支持的基本属性
        assert!(
            aria_manager.validate_attribute_value("true", &AriaAttributeType::Boolean),
            "true 应该是有效的布尔值"
        );
        assert!(
            aria_manager.validate_attribute_value("false", &AriaAttributeType::Boolean),
            "false 应该是有效的布尔值"
        );
        assert!(
            !aria_manager.validate_attribute_value("yes", &AriaAttributeType::Boolean),
            "yes 不应该是有效的布尔值"
        );

        // 测试枚举属性值
        let live_values = vec![
            "polite".to_string(),
            "assertive".to_string(),
            "off".to_string(),
        ];
        assert!(
            aria_manager.validate_attribute_value(
                "polite",
                &AriaAttributeType::Enumerated(live_values.clone())
            ),
            "polite 应该是有效的aria-live值"
        );
        assert!(
            !aria_manager
                .validate_attribute_value("quiet", &AriaAttributeType::Enumerated(live_values)),
            "quiet 不应该是有效的aria-live值"
        );

        // 测试ID引用属性
        assert!(
            aria_manager.validate_attribute_value("element-id", &AriaAttributeType::IdRef),
            "element-id 应该是有效的ID引用"
        );
        assert!(
            aria_manager.validate_attribute_value("id1 id2", &AriaAttributeType::IdRefList),
            "id1 id2 应该是有效的ID引用列表"
        );

        // 测试数字属性
        assert!(
            aria_manager.validate_attribute_value("100", &AriaAttributeType::Number),
            "100 应该是有效的数字"
        );
        assert!(
            !aria_manager.validate_attribute_value("high", &AriaAttributeType::Number),
            "high 不应该是有效的数字"
        );
    }

    #[test]
    fn test_implicit_role_detection() {
        let aria_manager = AriaManager::new();
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试按钮元素
        let button_html = r#"<button>点击我</button>"#;
        let dom = parser.parse(button_html).unwrap();
        let button = &dom.children[0];
        assert_eq!(aria_manager.get_implicit_role(button), Some("button"));

        // 测试带href属性的a元素
        // 修复: 使用转义或不同的引号方式处理href中的#字符
        let link_html = r##"<a href="#somewhere">链接</a>"##; // 使用r##"..."##语法
        let dom = parser.parse(link_html).unwrap();
        let link = &dom.children[0];
        assert_eq!(aria_manager.get_implicit_role(link), Some("link"));

        // 测试没有href属性的a元素
        let not_link_html = r#"<a>不是链接</a>"#;
        let dom = parser.parse(not_link_html).unwrap();
        let not_link = &dom.children[0];
        assert_eq!(aria_manager.get_implicit_role(not_link), None);

        // 测试带alt属性的img元素
        let img_html = r#"<img src="image.jpg" alt="图片描述" />"#;
        let dom = parser.parse(img_html).unwrap();
        let img = &dom.children[0];
        assert_eq!(aria_manager.get_implicit_role(img), Some("img"));

        // 测试不同类型的input元素
        let input_types = [
            ("text", "textbox"),
            ("button", "button"),
            ("checkbox", "checkbox"),
            ("radio", "radio"),
            ("range", "slider"),
        ];

        for (input_type, expected_role) in input_types.iter() {
            let input_html = format!(r#"<input type="{}" />"#, input_type);
            let dom = parser.parse(&input_html).unwrap();
            let input = &dom.children[0];
            assert_eq!(
                aria_manager.get_implicit_role(input),
                Some(*expected_role),
                "Input type '{}' should have role '{}'",
                input_type,
                expected_role
            );
        }

        // 测试标题元素
        let heading_html = r#"<h1>标题</h1>"#;
        let dom = parser.parse(heading_html).unwrap();
        let heading = &dom.children[0];
        assert_eq!(aria_manager.get_implicit_role(heading), Some("heading"));
    }

    #[test]
    fn test_aria_role_getter() {
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试显式角色
        let html = r#"<div role="alert">警告信息</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert_eq!(div.get_aria_role(), Some("alert".to_string()));

        // 测试隐式角色
        let html = r#"<button>按钮</button>"#;
        let dom = parser.parse(html).unwrap();
        let button = &dom.children[0];
        assert_eq!(button.get_aria_role(), Some("button".to_string()));

        // 测试没有角色的元素
        let html = r#"<span>普通文本</span>"#;
        let dom = parser.parse(html).unwrap();
        let span = &dom.children[0];
        assert_eq!(span.get_aria_role(), None);

        // 测试角色优先级：显式角色应该优先于隐式角色
        let html = r#"<button role="link">看起来像按钮但角色是链接</button>"#;
        let dom = parser.parse(html).unwrap();
        let button_link = &dom.children[0];
        assert_eq!(button_link.get_aria_role(), Some("link".to_string()));
    }

    #[test]
    fn test_accessible_name_calculation() {
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试aria-label
        let html = r#"<button aria-label="提交表单">提交</button>"#;
        let dom = parser.parse(html).unwrap();
        let button = &dom.children[0];
        assert_eq!(button.get_accessible_name(), "提交表单");

        // 测试title属性
        let html = r#"<button title="提交表单">提交</button>"#;
        let dom = parser.parse(html).unwrap();
        let button = &dom.children[0];
        assert_eq!(button.get_accessible_name(), "提交表单");

        // 测试内容文本
        let html = r#"<button>提交表单</button>"#;
        let dom = parser.parse(html).unwrap();
        let button = &dom.children[0];
        assert_eq!(button.get_accessible_name(), "提交表单");

        // 测试alt属性
        let html = r#"<img src="submit.jpg" alt="提交表单" />"#;
        let dom = parser.parse(html).unwrap();
        let img = &dom.children[0];
        assert_eq!(img.get_accessible_name(), "提交表单");

        // 测试优先级：aria-label > title > 内容文本
        let html = r#"<button aria-label="通过ARIA标签" title="通过标题">通过内容</button>"#;
        let dom = parser.parse(html).unwrap();
        let button = &dom.children[0];
        assert_eq!(button.get_accessible_name(), "通过ARIA标签");
    }

    #[test]
    fn test_aria_labelledby() {
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试aria-labelledby属性
        let html = r#"
            <div>
                <span id="label1">提交</span>
                <span id="label2">表单</span>
                <button aria-labelledby="label1 label2">按钮</button>
            </div>
        "#;
        let dom = parser.parse(html).unwrap();

        // 找到button元素
        let button = parser.query_selector(&dom, "button").unwrap();
        assert!(!button.is_empty(), "应该找到button元素");

        // 检查aria-labelledby属性是否正确
        let labelledby = button[0].get_attribute("aria-labelledby");
        assert_eq!(labelledby, Some("label1 label2"));

        // 在实际的应用中，这里可以测试完整的accessible name计算
        // 但这需要对DOM结构的完整解析和ID引用解析
    }

    #[test]
    fn test_accessibility_checker() {
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试有效的无障碍HTML
        let good_html = r##"
            <div>
                <h1>页面标题</h1>
                <img src="image.jpg" alt="图片描述" />
                <button aria-label="提交表单">提交</button>
                <a href="#link" aria-label="了解更多">更多</a>
            </div>
        "##; // 使用r##来处理包含#字符的字符串
        let dom = parser.parse(good_html).unwrap();
        let issues = parser.check_accessibility(&dom);
        assert!(issues.is_empty(), "应该没有无障碍性问题");

        // 测试无效的ARIA属性
        let bad_aria_html = r#"<button aria-pressed="yes">无效的ARIA属性值</button>"#;
        let dom = parser.parse(bad_aria_html).unwrap();
        let issues = parser.check_accessibility(&dom);
        assert!(!issues.is_empty(), "应该检测到无效的ARIA属性值");
        assert!(
            issues.iter().any(|issue| issue.contains("无效的ARIA属性")),
            "应该报告无效的ARIA属性"
        );

        // 测试缺少alt属性的图片
        let no_alt_html = r#"<img src="image.jpg" />"#;
        let dom = parser.parse(no_alt_html).unwrap();
        let issues = parser.check_accessibility(&dom);
        assert!(!issues.is_empty(), "应该检测到缺少alt属性");
        assert!(
            issues.iter().any(|issue| issue.contains("缺少alt属性")),
            "应该报告缺少alt属性"
        );

        // 测试无效的role属性
        let bad_role_html = r#"<div role="invalidrole">无效的角色</div>"#;
        let dom = parser.parse(bad_role_html).unwrap();
        let issues = parser.check_accessibility(&dom);
        assert!(!issues.is_empty(), "应该检测到无效的角色");
        assert!(
            issues.iter().any(|issue| issue.contains("无效的ARIA角色")),
            "应该报告无效的角色"
        );
    }

    #[test]
    fn test_is_accessible() {
        let parser = HtmlParser::new(ParserConfig::default());

        // 测试aria-hidden="true"
        let html = r#"<div aria-hidden="true">隐藏内容</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert!(!div.is_accessible());

        // 测试aria-hidden="false"
        let html = r#"<div aria-hidden="false">可见内容</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert!(div.is_accessible());

        // 测试display: none
        let html = r#"<div style="display: none;">隐藏内容</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert!(!div.is_accessible());

        // 测试visibility: hidden
        let html = r#"<div style="visibility: hidden;">隐藏内容</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert!(!div.is_accessible());

        // 测试默认情况
        let html = r#"<div>可见内容</div>"#;
        let dom = parser.parse(html).unwrap();
        let div = &dom.children[0];
        assert!(div.is_accessible());
    }
}
